// CodeContracts
// 
// Copyright (c) Microsoft Corporation
// 
// All rights reserved. 
// 
// MIT License
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

using System;
using System.Compiler;

namespace Microsoft.Contracts.Foxtrot {
  public class EventingVisitor : StandardVisitor {
    public EventingVisitor() { }
    public EventingVisitor(Action<Node> visitNode) { VisitedNode += visitNode; } public event Action<Node> VisitedNode; public override Node Visit(Node node) { if (VisitedNode != null) VisitedNode(node); return base.Visit(node); }
    public EventingVisitor(Action<Acquire> visitAcquire) { VisitedAcquire += visitAcquire; } public event Action<Acquire> VisitedAcquire; public override Statement VisitAcquire(Acquire acquire) { if (VisitedAcquire != null) VisitedAcquire(acquire); return base.VisitAcquire(acquire); }
    public EventingVisitor(Action<AddressDereference> visitAddressDereference) { VisitedAddressDereference += visitAddressDereference; } public event Action<AddressDereference> VisitedAddressDereference; public override Expression VisitAddressDereference(AddressDereference addr) { if (VisitedAddressDereference != null) VisitedAddressDereference(addr); return base.VisitAddressDereference(addr); }
    public EventingVisitor(Action<AliasDefinition> visitAliasDefinition) { VisitedAliasDefinition += visitAliasDefinition; } public event Action<AliasDefinition> VisitedAliasDefinition; public override AliasDefinition VisitAliasDefinition(AliasDefinition aliasDefinition) { if (VisitedAliasDefinition != null) VisitedAliasDefinition(aliasDefinition); return base.VisitAliasDefinition(aliasDefinition); }
    public EventingVisitor(Action<AliasDefinitionList> visitAliasDefinitionList) { VisitedAliasDefinitionList += visitAliasDefinitionList; } public event Action<AliasDefinitionList> VisitedAliasDefinitionList; public override AliasDefinitionList VisitAliasDefinitionList(AliasDefinitionList aliasDefinitions) { if (VisitedAliasDefinitionList != null) VisitedAliasDefinitionList(aliasDefinitions); return base.VisitAliasDefinitionList(aliasDefinitions); }
    public EventingVisitor(Action<AnonymousNestedFunction> visitAnonymousNestedFunction) { VisitedAnonymousNestedFunction += visitAnonymousNestedFunction; } public event Action<AnonymousNestedFunction> VisitedAnonymousNestedFunction; public override Expression VisitAnonymousNestedFunction(AnonymousNestedFunction func) { if (VisitedAnonymousNestedFunction != null) VisitedAnonymousNestedFunction(func); return base.VisitAnonymousNestedFunction(func); }
    public EventingVisitor(Action<ApplyToAll> visitApplyToAll) { VisitedApplyToAll += visitApplyToAll; } public event Action<ApplyToAll> VisitedApplyToAll; public override Expression VisitApplyToAll(ApplyToAll applyToAll) { if (VisitedApplyToAll != null) VisitedApplyToAll(applyToAll); return base.VisitApplyToAll(applyToAll); }
    public EventingVisitor(Action<ArglistArgumentExpression> visitArglistArgumentExpression) { VisitedArglistArgumentExpression += visitArglistArgumentExpression; } public event Action<ArglistArgumentExpression> VisitedArglistArgumentExpression; public override Expression VisitArglistArgumentExpression(ArglistArgumentExpression argexp) { if (VisitedArglistArgumentExpression != null) VisitedArglistArgumentExpression(argexp); return base.VisitArglistArgumentExpression(argexp); }
    public EventingVisitor(Action<ArglistExpression> visitArglistExpression) { VisitedArglistExpression += visitArglistExpression; } public event Action<ArglistExpression> VisitedArglistExpression; public override Expression VisitArglistExpression(ArglistExpression argexp) { if (VisitedArglistExpression != null) VisitedArglistExpression(argexp); return base.VisitArglistExpression(argexp); }
    public EventingVisitor(Action<AssemblyNode> visitAssembly) { VisitedAssembly += visitAssembly; } public event Action<AssemblyNode> VisitedAssembly; public override AssemblyNode VisitAssembly(AssemblyNode assembly) { if (VisitedAssembly != null) VisitedAssembly(assembly); return base.VisitAssembly(assembly); }
    public EventingVisitor(Action<AssemblyReference> visitAssemblyReference) { VisitedAssemblyReference += visitAssemblyReference; } public event Action<AssemblyReference> VisitedAssemblyReference; public override AssemblyReference VisitAssemblyReference(AssemblyReference assemblyReference) { if (VisitedAssemblyReference != null) VisitedAssemblyReference(assemblyReference); return base.VisitAssemblyReference(assemblyReference); }
    public EventingVisitor(Action<Assertion> visitAssertion) { VisitedAssertion += visitAssertion; } public event Action<Assertion> VisitedAssertion; public override Statement VisitAssertion(Assertion assertion) { if (VisitedAssertion != null) VisitedAssertion(assertion); return base.VisitAssertion(assertion); }
    public EventingVisitor(Action<AssignmentExpression> visitAssignmentExpression) { VisitedAssignmentExpression += visitAssignmentExpression; } public event Action<AssignmentExpression> VisitedAssignmentExpression; public override Expression VisitAssignmentExpression(AssignmentExpression assignment) { if (VisitedAssignmentExpression != null) VisitedAssignmentExpression(assignment); return base.VisitAssignmentExpression(assignment); }
    public EventingVisitor(Action<AssignmentStatement> visitAssignmentStatement) { VisitedAssignmentStatement += visitAssignmentStatement; } public event Action<AssignmentStatement> VisitedAssignmentStatement; public override Statement VisitAssignmentStatement(AssignmentStatement assignment) { if (VisitedAssignmentStatement != null) VisitedAssignmentStatement(assignment); return base.VisitAssignmentStatement(assignment); }
    public EventingVisitor(Action<Assumption> visitAssumption) { VisitedAssumption += visitAssumption; } public event Action<Assumption> VisitedAssumption; public override Statement VisitAssumption(Assumption assumption) { if (VisitedAssumption != null) VisitedAssumption(assumption); return base.VisitAssumption(assumption); }
    public event Action<AttributeNode> VisitedAttributeConstructor; public override Expression VisitAttributeConstructor(AttributeNode attribute) { if (VisitedAttributeConstructor != null) VisitedAttributeConstructor(attribute); return base.VisitAttributeConstructor(attribute); }
    public EventingVisitor(Action<AttributeList> visitAttributeList) { VisitedAttributeList += visitAttributeList; } public event Action<AttributeList> VisitedAttributeList; public override AttributeList VisitAttributeList(AttributeList attributes) { if (VisitedAttributeList != null) VisitedAttributeList(attributes); return base.VisitAttributeList(attributes); }
    public EventingVisitor(Action<AttributeNode> visitAttributeNode) { VisitedAttributeNode += visitAttributeNode; } public event Action<AttributeNode> VisitedAttributeNode; public override AttributeNode VisitAttributeNode(AttributeNode attribute) { if (VisitedAttributeNode != null) VisitedAttributeNode(attribute); return base.VisitAttributeNode(attribute); }
    public EventingVisitor(Action<Base> visitBase) { VisitedBase += visitBase; } public event Action<Base> VisitedBase; public override Expression VisitBase(Base Base) { if (VisitedBase != null) VisitedBase(Base); return base.VisitBase(Base); }
    public EventingVisitor(Action<BinaryExpression> visitBinaryExpression) { VisitedBinaryExpression += visitBinaryExpression; } public event Action<BinaryExpression> VisitedBinaryExpression; public override Expression VisitBinaryExpression(BinaryExpression binaryExpression) { if (VisitedBinaryExpression != null) VisitedBinaryExpression(binaryExpression); return base.VisitBinaryExpression(binaryExpression); }
    public EventingVisitor(Action<Block> visitBlock) { VisitedBlock += visitBlock; } public event Action<Block> VisitedBlock; public override Block VisitBlock(Block block) { if (VisitedBlock != null) VisitedBlock(block); return base.VisitBlock(block); }
    public EventingVisitor(Action<BlockExpression> visitBlockExpression) { VisitedBlockExpression += visitBlockExpression; } public event Action<BlockExpression> VisitedBlockExpression; public override Expression VisitBlockExpression(BlockExpression blockExpression) { if (VisitedBlockExpression != null) VisitedBlockExpression(blockExpression); return base.VisitBlockExpression(blockExpression); }
    public EventingVisitor(Action<BlockList> visitBlockList) { VisitedBlockList += visitBlockList; } public event Action<BlockList> VisitedBlockList; public override BlockList VisitBlockList(BlockList blockList) { if (VisitedBlockList != null) VisitedBlockList(blockList); return base.VisitBlockList(blockList); }
    public EventingVisitor(Action<Branch> visitBranch) { VisitedBranch += visitBranch; } public event Action<Branch> VisitedBranch; public override Statement VisitBranch(Branch branch) { if (VisitedBranch != null) VisitedBranch(branch); return base.VisitBranch(branch); }
    public EventingVisitor(Action<Catch> visitCatch) { VisitedCatch += visitCatch; } public event Action<Catch> VisitedCatch; public override Statement VisitCatch(Catch Catch) { if (VisitedCatch != null) VisitedCatch(Catch); return base.VisitCatch(Catch); }
    public EventingVisitor(Action<CatchList> visitCatchList) { VisitedCatchList += visitCatchList; } public event Action<CatchList> VisitedCatchList; public override CatchList VisitCatchList(CatchList catchers) { if (VisitedCatchList != null) VisitedCatchList(catchers); return base.VisitCatchList(catchers); }
    public EventingVisitor(Action<Class> visitClass) { VisitedClass += visitClass; } public event Action<Class> VisitedClass; public override Class VisitClass(Class Class) { if (VisitedClass != null) VisitedClass(Class); return base.VisitClass(Class); }
    public EventingVisitor(Action<CoerceTuple> visitCoerceTuple) { VisitedCoerceTuple += visitCoerceTuple; } public event Action<CoerceTuple> VisitedCoerceTuple; public override Expression VisitCoerceTuple(CoerceTuple coerceTuple) { if (VisitedCoerceTuple != null) VisitedCoerceTuple(coerceTuple); return base.VisitCoerceTuple(coerceTuple); }
    public EventingVisitor(Action<CollectionEnumerator> visitCollectionEnumerator) { VisitedCollectionEnumerator += visitCollectionEnumerator; } public event Action<CollectionEnumerator> VisitedCollectionEnumerator; public override CollectionEnumerator VisitCollectionEnumerator(CollectionEnumerator ce) { if (VisitedCollectionEnumerator != null) VisitedCollectionEnumerator(ce); return base.VisitCollectionEnumerator(ce); }
    public EventingVisitor(Action<Compilation> visitCompilation) { VisitedCompilation += visitCompilation; } public event Action<Compilation> VisitedCompilation; public override Compilation VisitCompilation(Compilation compilation) { if (VisitedCompilation != null) VisitedCompilation(compilation); return base.VisitCompilation(compilation); }
    public EventingVisitor(Action<CompilationUnit> visitCompilationUnit) { VisitedCompilationUnit += visitCompilationUnit; } public event Action<CompilationUnit> VisitedCompilationUnit; public override CompilationUnit VisitCompilationUnit(CompilationUnit cUnit) { if (VisitedCompilationUnit != null) VisitedCompilationUnit(cUnit); return base.VisitCompilationUnit(cUnit); }
    public EventingVisitor(Action<CompilationUnitList> visitCompilationUnitList) { VisitedCompilationUnitList += visitCompilationUnitList; } public event Action<CompilationUnitList> VisitedCompilationUnitList; public override CompilationUnitList VisitCompilationUnitList(CompilationUnitList compilationUnits) { if (VisitedCompilationUnitList != null) VisitedCompilationUnitList(compilationUnits); return base.VisitCompilationUnitList(compilationUnits); }
    public EventingVisitor(Action<CompilationUnitSnippet> visitCompilationUnitSnippet) { VisitedCompilationUnitSnippet += visitCompilationUnitSnippet; } public event Action<CompilationUnitSnippet> VisitedCompilationUnitSnippet; public override CompilationUnit VisitCompilationUnitSnippet(CompilationUnitSnippet snippet) { if (VisitedCompilationUnitSnippet != null) VisitedCompilationUnitSnippet(snippet); return base.VisitCompilationUnitSnippet(snippet); }
    public EventingVisitor(Action<Composition> visitComposition) { VisitedComposition += visitComposition; } public event Action<Composition> VisitedComposition; public override Node VisitComposition(Composition comp) { if (VisitedComposition != null) VisitedComposition(comp); return base.VisitComposition(comp); }
    public EventingVisitor(Action<Comprehension> visitComprehension) { VisitedComprehension += visitComprehension; } public event Action<Comprehension> VisitedComprehension; public override Expression VisitComprehension(Comprehension comprehension) { if (VisitedComprehension != null) VisitedComprehension(comprehension); return base.VisitComprehension(comprehension); }
    public EventingVisitor(Action<ComprehensionBinding> visitComprehensionBinding) { VisitedComprehensionBinding += visitComprehensionBinding; } public event Action<ComprehensionBinding> VisitedComprehensionBinding; public override ComprehensionBinding VisitComprehensionBinding(ComprehensionBinding comprehensionBinding) { if (VisitedComprehensionBinding != null) VisitedComprehensionBinding(comprehensionBinding); return base.VisitComprehensionBinding(comprehensionBinding); }
    public EventingVisitor(Action<ConstrainedType> visitConstrainedType) { VisitedConstrainedType += visitConstrainedType; } public event Action<ConstrainedType> VisitedConstrainedType; public override TypeNode VisitConstrainedType(ConstrainedType cType) { if (VisitedConstrainedType != null) VisitedConstrainedType(cType); return base.VisitConstrainedType(cType); }
    public EventingVisitor(Action<Construct> visitConstruct) { VisitedConstruct += visitConstruct; } public event Action<Construct> VisitedConstruct; public override Expression VisitConstruct(Construct cons) { if (VisitedConstruct != null) VisitedConstruct(cons); return base.VisitConstruct(cons); }
    public EventingVisitor(Action<ConstructArray> visitConstructArray) { VisitedConstructArray += visitConstructArray; } public event Action<ConstructArray> VisitedConstructArray; public override Expression VisitConstructArray(ConstructArray consArr) { if (VisitedConstructArray != null) VisitedConstructArray(consArr); return base.VisitConstructArray(consArr); }
    public EventingVisitor(Action<ConstructDelegate> visitConstructDelegate) { VisitedConstructDelegate += visitConstructDelegate; } public event Action<ConstructDelegate> VisitedConstructDelegate; public override Expression VisitConstructDelegate(ConstructDelegate consDelegate) { if (VisitedConstructDelegate != null) VisitedConstructDelegate(consDelegate); return base.VisitConstructDelegate(consDelegate); }
    public EventingVisitor(Action<ConstructFlexArray> visitConstructFlexArray) { VisitedConstructFlexArray += visitConstructFlexArray; } public event Action<ConstructFlexArray> VisitedConstructFlexArray; public override Expression VisitConstructFlexArray(ConstructFlexArray consArr) { if (VisitedConstructFlexArray != null) VisitedConstructFlexArray(consArr); return base.VisitConstructFlexArray(consArr); }
    public EventingVisitor(Action<ConstructIterator> visitConstructIterator) { VisitedConstructIterator += visitConstructIterator; } public event Action<ConstructIterator> VisitedConstructIterator; public override Expression VisitConstructIterator(ConstructIterator consIterator) { if (VisitedConstructIterator != null) VisitedConstructIterator(consIterator); return base.VisitConstructIterator(consIterator); }
    public EventingVisitor(Action<ConstructTuple> visitConstructTuple) { VisitedConstructTuple += visitConstructTuple; } public event Action<ConstructTuple> VisitedConstructTuple; public override Expression VisitConstructTuple(ConstructTuple consTuple) { if (VisitedConstructTuple != null) VisitedConstructTuple(consTuple); return base.VisitConstructTuple(consTuple); }
    public EventingVisitor(Action<Continue> visitContinue) { VisitedContinue += visitContinue; } public event Action<Continue> VisitedContinue; public override Statement VisitContinue(Continue Continue) { if (VisitedContinue != null) VisitedContinue(Continue); return base.VisitContinue(Continue); }
    public EventingVisitor(Action<CurrentClosure> visitCurrentClosure) { VisitedCurrentClosure += visitCurrentClosure; } public event Action<CurrentClosure> VisitedCurrentClosure; public override Expression VisitCurrentClosure(CurrentClosure currentClosure) { if (VisitedCurrentClosure != null) VisitedCurrentClosure(currentClosure); return base.VisitCurrentClosure(currentClosure); }
    public EventingVisitor(Action<DelegateNode> visitDelegateNode) { VisitedDelegateNode += visitDelegateNode; } public event Action<DelegateNode> VisitedDelegateNode; public override DelegateNode VisitDelegateNode(DelegateNode delegateNode) { if (VisitedDelegateNode != null) VisitedDelegateNode(delegateNode); return base.VisitDelegateNode(delegateNode); }
    public EventingVisitor(Action<DoWhile> visitDoWhile) { VisitedDoWhile += visitDoWhile; } public event Action<DoWhile> VisitedDoWhile; public override Statement VisitDoWhile(DoWhile doWhile) { if (VisitedDoWhile != null) VisitedDoWhile(doWhile); return base.VisitDoWhile(doWhile); }
    public EventingVisitor(Action<EndFilter> visitEndFilter) { VisitedEndFilter += visitEndFilter; } public event Action<EndFilter> VisitedEndFilter; public override Statement VisitEndFilter(EndFilter endFilter) { if (VisitedEndFilter != null) VisitedEndFilter(endFilter); return base.VisitEndFilter(endFilter); }
    public EventingVisitor(Action<EndFinally> visitEndFinally) { VisitedEndFinally += visitEndFinally; } public event Action<EndFinally> VisitedEndFinally; public override Statement VisitEndFinally(EndFinally endFinally) { if (VisitedEndFinally != null) VisitedEndFinally(endFinally); return base.VisitEndFinally(endFinally); }
    public EventingVisitor(Action<EnsuresExceptional> visitEnsuresExceptional) { VisitedEnsuresExceptional += visitEnsuresExceptional; } public event Action<EnsuresExceptional> VisitedEnsuresExceptional; public override EnsuresExceptional VisitEnsuresExceptional(EnsuresExceptional exceptional) { if (VisitedEnsuresExceptional != null) VisitedEnsuresExceptional(exceptional); return base.VisitEnsuresExceptional(exceptional); }
    public EventingVisitor(Action<EnsuresList> visitEnsuresList) { VisitedEnsuresList += visitEnsuresList; } public event Action<EnsuresList> VisitedEnsuresList; public override EnsuresList VisitEnsuresList(EnsuresList Ensures) { if (VisitedEnsuresList != null) VisitedEnsuresList(Ensures); return base.VisitEnsuresList(Ensures); }
    public EventingVisitor(Action<EnsuresNormal> visitEnsuresNormal) { VisitedEnsuresNormal += visitEnsuresNormal; } public event Action<EnsuresNormal> VisitedEnsuresNormal; public override EnsuresNormal VisitEnsuresNormal(EnsuresNormal normal) { if (VisitedEnsuresNormal != null) VisitedEnsuresNormal(normal); return base.VisitEnsuresNormal(normal); }
    public EventingVisitor(Action<EnumNode> visitEnumNode) { VisitedEnumNode += visitEnumNode; } public event Action<EnumNode> VisitedEnumNode; public override EnumNode VisitEnumNode(EnumNode enumNode) { if (VisitedEnumNode != null) VisitedEnumNode(enumNode); return base.VisitEnumNode(enumNode); }
    public EventingVisitor(Action<Event> visitEvent) { VisitedEvent += visitEvent; } public event Action<Event> VisitedEvent; public override Event VisitEvent(Event evnt) { if (VisitedEvent != null) VisitedEvent(evnt); return base.VisitEvent(evnt); }
    public EventingVisitor(Action<Exit> visitExit) { VisitedExit += visitExit; } public event Action<Exit> VisitedExit; public override Statement VisitExit(Exit exit) { if (VisitedExit != null) VisitedExit(exit); return base.VisitExit(exit); }
    public EventingVisitor(Action<Expose> visitExpose) { VisitedExpose += visitExpose; } public event Action<Expose> VisitedExpose; public override Statement VisitExpose(Expose expose) { if (VisitedExpose != null) VisitedExpose(expose); return base.VisitExpose(expose); }
    public EventingVisitor(Action<Expression> visitExpression) { VisitedExpression += visitExpression; } public event Action<Expression> VisitedExpression; public override Expression VisitExpression(Expression expression) { if (VisitedExpression != null) VisitedExpression(expression); return base.VisitExpression(expression); }
    public EventingVisitor(Action<ExpressionList> visitExpressionList) { VisitedExpressionList += visitExpressionList; } public event Action<ExpressionList> VisitedExpressionList; public override ExpressionList VisitExpressionList(ExpressionList expressions) { if (VisitedExpressionList != null) VisitedExpressionList(expressions); return base.VisitExpressionList(expressions); }
    public EventingVisitor(Action<ExpressionSnippet> visitExpressionSnippet) { VisitedExpressionSnippet += visitExpressionSnippet; } public event Action<ExpressionSnippet> VisitedExpressionSnippet; public override Expression VisitExpressionSnippet(ExpressionSnippet snippet) { if (VisitedExpressionSnippet != null) VisitedExpressionSnippet(snippet); return base.VisitExpressionSnippet(snippet); }
    public EventingVisitor(Action<ExpressionStatement> visitExpressionStatement) { VisitedExpressionStatement += visitExpressionStatement; } public event Action<ExpressionStatement> VisitedExpressionStatement; public override Statement VisitExpressionStatement(ExpressionStatement statement) { if (VisitedExpressionStatement != null) VisitedExpressionStatement(statement); return base.VisitExpressionStatement(statement); }
    public EventingVisitor(Action<FaultHandler> visitFaultHandler) { VisitedFaultHandler += visitFaultHandler; } public event Action<FaultHandler> VisitedFaultHandler; public override Statement VisitFaultHandler(FaultHandler faultHandler) { if (VisitedFaultHandler != null) VisitedFaultHandler(faultHandler); return base.VisitFaultHandler(faultHandler); }
    public EventingVisitor(Action<FaultHandlerList> visitFaultHandlerList) { VisitedFaultHandlerList += visitFaultHandlerList; } public event Action<FaultHandlerList> VisitedFaultHandlerList; public override FaultHandlerList VisitFaultHandlerList(FaultHandlerList faultHandlers) { if (VisitedFaultHandlerList != null) VisitedFaultHandlerList(faultHandlers); return base.VisitFaultHandlerList(faultHandlers); }
    public EventingVisitor(Action<Field> visitField) { VisitedField += visitField; } public event Action<Field> VisitedField; public override Field VisitField(Field field) { if (VisitedField != null) VisitedField(field); return base.VisitField(field); }
    public EventingVisitor(Action<FieldInitializerBlock> visitFieldInitializerBlock) { VisitedFieldInitializerBlock += visitFieldInitializerBlock; } public event Action<FieldInitializerBlock> VisitedFieldInitializerBlock; public override Block VisitFieldInitializerBlock(FieldInitializerBlock block) { if (VisitedFieldInitializerBlock != null) VisitedFieldInitializerBlock(block); return base.VisitFieldInitializerBlock(block); }
    public EventingVisitor(Action<FieldList> visitFieldList) { VisitedFieldList += visitFieldList; } public event Action<FieldList> VisitedFieldList; public override FieldList VisitFieldList(FieldList fields) { if (VisitedFieldList != null) VisitedFieldList(fields); return base.VisitFieldList(fields); }
    public EventingVisitor(Action<Filter> visitFilter) { VisitedFilter += visitFilter; } public event Action<Filter> VisitedFilter; public override Statement VisitFilter(Filter filter) { if (VisitedFilter != null) VisitedFilter(filter); return base.VisitFilter(filter); }
    public EventingVisitor(Action<FilterList> visitFilterList) { VisitedFilterList += visitFilterList; } public event Action<FilterList> VisitedFilterList; public override FilterList VisitFilterList(FilterList filters) { if (VisitedFilterList != null) VisitedFilterList(filters); return base.VisitFilterList(filters); }
    public EventingVisitor(Action<Finally> visitFinally) { VisitedFinally += visitFinally; } public event Action<Finally> VisitedFinally; public override Statement VisitFinally(Finally Finally) { if (VisitedFinally != null) VisitedFinally(Finally); return base.VisitFinally(Finally); }
    public EventingVisitor(Action<Fixed> visitFixed) { VisitedFixed += visitFixed; } public event Action<Fixed> VisitedFixed; public override Statement VisitFixed(Fixed Fixed) { if (VisitedFixed != null) VisitedFixed(Fixed); return base.VisitFixed(Fixed); }
    public EventingVisitor(Action<For> visitFor) { VisitedFor += visitFor; } public event Action<For> VisitedFor; public override Statement VisitFor(For For) { if (VisitedFor != null) VisitedFor(For); return base.VisitFor(For); }
    public EventingVisitor(Action<ForEach> visitForEach) { VisitedForEach += visitForEach; } public event Action<ForEach> VisitedForEach; public override Statement VisitForEach(ForEach forEach) { if (VisitedForEach != null) VisitedForEach(forEach); return base.VisitForEach(forEach); }
    public EventingVisitor(Action<FunctionDeclaration> visitFunctionDeclaration) { VisitedFunctionDeclaration += visitFunctionDeclaration; } public event Action<FunctionDeclaration> VisitedFunctionDeclaration; public override Statement VisitFunctionDeclaration(FunctionDeclaration functionDeclaration) { if (VisitedFunctionDeclaration != null) VisitedFunctionDeclaration(functionDeclaration); return base.VisitFunctionDeclaration(functionDeclaration); }
    public EventingVisitor(Action<Goto> visitGoto) { VisitedGoto += visitGoto; } public event Action<Goto> VisitedGoto; public override Statement VisitGoto(Goto Goto) { if (VisitedGoto != null) VisitedGoto(Goto); return base.VisitGoto(Goto); }
    public EventingVisitor(Action<GotoCase> visitGotoCase) { VisitedGotoCase += visitGotoCase; } public event Action<GotoCase> VisitedGotoCase; public override Statement VisitGotoCase(GotoCase gotoCase) { if (VisitedGotoCase != null) VisitedGotoCase(gotoCase); return base.VisitGotoCase(gotoCase); }
    public EventingVisitor(Action<Identifier> visitIdentifier) { VisitedIdentifier += visitIdentifier; } public event Action<Identifier> VisitedIdentifier; public override Expression VisitIdentifier(Identifier identifier) { if (VisitedIdentifier != null) VisitedIdentifier(identifier); return base.VisitIdentifier(identifier); }
    public EventingVisitor(Action<If> visitIf) { VisitedIf += visitIf; } public event Action<If> VisitedIf; public override Statement VisitIf(If If) { if (VisitedIf != null) VisitedIf(If); return base.VisitIf(If); }
    public EventingVisitor(Action<ImplicitThis> visitImplicitThis) { VisitedImplicitThis += visitImplicitThis; } public event Action<ImplicitThis> VisitedImplicitThis; public override Expression VisitImplicitThis(ImplicitThis implicitThis) { if (VisitedImplicitThis != null) VisitedImplicitThis(implicitThis); return base.VisitImplicitThis(implicitThis); }
    public EventingVisitor(Action<Indexer> visitIndexer) { VisitedIndexer += visitIndexer; } public event Action<Indexer> VisitedIndexer; public override Expression VisitIndexer(Indexer indexer) { if (VisitedIndexer != null) VisitedIndexer(indexer); return base.VisitIndexer(indexer); }
    public EventingVisitor(Action<InstanceInitializer> visitInstanceInitializer) { VisitedInstanceInitializer += visitInstanceInitializer; } public event Action<InstanceInitializer> VisitedInstanceInitializer; public override InstanceInitializer VisitInstanceInitializer(InstanceInitializer cons) { if (VisitedInstanceInitializer != null) VisitedInstanceInitializer(cons); return base.VisitInstanceInitializer(cons); }
    public EventingVisitor(Action<Interface> visitInterface) { VisitedInterface += visitInterface; } public event Action<Interface> VisitedInterface; public override Interface VisitInterface(Interface Interface) { if (VisitedInterface != null) VisitedInterface(Interface); return base.VisitInterface(Interface); }
    public event Action<Interface> VisitedInterfaceReference; public override Interface VisitInterfaceReference(Interface Interface) { if (VisitedInterfaceReference != null) VisitedInterfaceReference(Interface); return base.VisitInterfaceReference(Interface); }
    public EventingVisitor(Action<InterfaceList> visitInterfaceReferenceList) { VisitedInterfaceReferenceList += visitInterfaceReferenceList; } public event Action<InterfaceList> VisitedInterfaceReferenceList; public override InterfaceList VisitInterfaceReferenceList(InterfaceList interfaceReferences) { if (VisitedInterfaceReferenceList != null) VisitedInterfaceReferenceList(interfaceReferences); return base.VisitInterfaceReferenceList(interfaceReferences); }
    public EventingVisitor(Action<Invariant> visitInvariant) { VisitedInvariant += visitInvariant; } public event Action<Invariant> VisitedInvariant; public override Invariant VisitInvariant(Invariant invariant) { if (VisitedInvariant != null) VisitedInvariant(invariant); return base.VisitInvariant(invariant); }
    public EventingVisitor(Action<InvariantList> visitInvariantList) { VisitedInvariantList += visitInvariantList; } public event Action<InvariantList> VisitedInvariantList; public override InvariantList VisitInvariantList(InvariantList invariants) { if (VisitedInvariantList != null) VisitedInvariantList(invariants); return base.VisitInvariantList(invariants); }
    public EventingVisitor(Action<LabeledStatement> visitLabeledStatement) { VisitedLabeledStatement += visitLabeledStatement; } public event Action<LabeledStatement> VisitedLabeledStatement; public override Statement VisitLabeledStatement(LabeledStatement lStatement) { if (VisitedLabeledStatement != null) VisitedLabeledStatement(lStatement); return base.VisitLabeledStatement(lStatement); }
    public EventingVisitor(Action<Literal> visitLiteral) { VisitedLiteral += visitLiteral; } public event Action<Literal> VisitedLiteral; public override Expression VisitLiteral(Literal literal) { if (VisitedLiteral != null) VisitedLiteral(literal); return base.VisitLiteral(literal); }
    public EventingVisitor(Action<Local> visitLocal) { VisitedLocal += visitLocal; } public event Action<Local> VisitedLocal; public override Expression VisitLocal(Local local) { if (VisitedLocal != null) VisitedLocal(local); return base.VisitLocal(local); }
    public EventingVisitor(Action<LocalDeclaration> visitLocalDeclaration) { VisitedLocalDeclaration += visitLocalDeclaration; } public event Action<LocalDeclaration> VisitedLocalDeclaration; public override LocalDeclaration VisitLocalDeclaration(LocalDeclaration localDeclaration) { if (VisitedLocalDeclaration != null) VisitedLocalDeclaration(localDeclaration); return base.VisitLocalDeclaration(localDeclaration); }
    public EventingVisitor(Action<LocalDeclarationList> visitLocalDeclarationList) { VisitedLocalDeclarationList += visitLocalDeclarationList; } public event Action<LocalDeclarationList> VisitedLocalDeclarationList; public override LocalDeclarationList VisitLocalDeclarationList(LocalDeclarationList localDeclarations) { if (VisitedLocalDeclarationList != null) VisitedLocalDeclarationList(localDeclarations); return base.VisitLocalDeclarationList(localDeclarations); }
    public EventingVisitor(Action<LocalDeclarationsStatement> visitLocalDeclarationsStatement) { VisitedLocalDeclarationsStatement += visitLocalDeclarationsStatement; } public event Action<LocalDeclarationsStatement> VisitedLocalDeclarationsStatement; public override Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations) { if (VisitedLocalDeclarationsStatement != null) VisitedLocalDeclarationsStatement(localDeclarations); return base.VisitLocalDeclarationsStatement(localDeclarations); }
    public EventingVisitor(Action<Lock> visitLock) { VisitedLock += visitLock; } public event Action<Lock> VisitedLock; public override Statement VisitLock(Lock Lock) { if (VisitedLock != null) VisitedLock(Lock); return base.VisitLock(Lock); }
    public event Action<ExpressionList> VisitedLoopInvariantList; public override ExpressionList VisitLoopInvariantList(ExpressionList expressions) { if (VisitedLoopInvariantList != null) VisitedLoopInvariantList(expressions); return base.VisitLoopInvariantList(expressions); }
    public EventingVisitor(Action<LRExpression> visitLRExpression) { VisitedLRExpression += visitLRExpression; } public event Action<LRExpression> VisitedLRExpression; public override Expression VisitLRExpression(LRExpression expr) { if (VisitedLRExpression != null) VisitedLRExpression(expr); return base.VisitLRExpression(expr); }
    public EventingVisitor(Action<MemberBinding> visitMemberBinding) { VisitedMemberBinding += visitMemberBinding; } public event Action<MemberBinding> VisitedMemberBinding; public override Expression VisitMemberBinding(MemberBinding memberBinding) { if (VisitedMemberBinding != null) VisitedMemberBinding(memberBinding); return base.VisitMemberBinding(memberBinding); }
    public EventingVisitor(Action<MemberList> visitMemberList) { VisitedMemberList += visitMemberList; } public event Action<MemberList> VisitedMemberList; public override MemberList VisitMemberList(MemberList members) { if (VisitedMemberList != null) VisitedMemberList(members); return base.VisitMemberList(members); }
    public EventingVisitor(Action<Method> visitMethod) { VisitedMethod += visitMethod; } public event Action<Method> VisitedMethod; public override Method VisitMethod(Method method) { if (VisitedMethod != null) VisitedMethod(method); return base.VisitMethod(method); }
    public EventingVisitor(Action<MethodCall> visitMethodCall) { VisitedMethodCall += visitMethodCall; } public event Action<MethodCall> VisitedMethodCall; public override Expression VisitMethodCall(MethodCall call) { if (VisitedMethodCall != null) VisitedMethodCall(call); return base.VisitMethodCall(call); }
    public EventingVisitor(Action<MethodContract> visitMethodContract) { VisitedMethodContract += visitMethodContract; } public event Action<MethodContract> VisitedMethodContract; public override MethodContract VisitMethodContract(MethodContract contract) { if (VisitedMethodContract != null) VisitedMethodContract(contract); return base.VisitMethodContract(contract); }
    public EventingVisitor(Action<Module> visitModule) { VisitedModule += visitModule; } public event Action<Module> VisitedModule; public override Module VisitModule(Module module) { if (VisitedModule != null) VisitedModule(module); return base.VisitModule(module); }
    public EventingVisitor(Action<ModuleReference> visitModuleReference) { VisitedModuleReference += visitModuleReference; } public event Action<ModuleReference> VisitedModuleReference; public override ModuleReference VisitModuleReference(ModuleReference moduleReference) { if (VisitedModuleReference != null) VisitedModuleReference(moduleReference); return base.VisitModuleReference(moduleReference); }
    public EventingVisitor(Action<NameBinding> visitNameBinding) { VisitedNameBinding += visitNameBinding; } public event Action<NameBinding> VisitedNameBinding; public override Expression VisitNameBinding(NameBinding nameBinding) { if (VisitedNameBinding != null) VisitedNameBinding(nameBinding); return base.VisitNameBinding(nameBinding); }
    public EventingVisitor(Action<NamedArgument> visitNamedArgument) { VisitedNamedArgument += visitNamedArgument; } public event Action<NamedArgument> VisitedNamedArgument; public override Expression VisitNamedArgument(NamedArgument namedArgument) { if (VisitedNamedArgument != null) VisitedNamedArgument(namedArgument); return base.VisitNamedArgument(namedArgument); }
    public EventingVisitor(Action<Namespace> visitNamespace) { VisitedNamespace += visitNamespace; } public event Action<Namespace> VisitedNamespace; public override Namespace VisitNamespace(Namespace nspace) { if (VisitedNamespace != null) VisitedNamespace(nspace); return base.VisitNamespace(nspace); }
    public EventingVisitor(Action<NamespaceList> visitNamespaceList) { VisitedNamespaceList += visitNamespaceList; } public event Action<NamespaceList> VisitedNamespaceList; public override NamespaceList VisitNamespaceList(NamespaceList namespaces) { if (VisitedNamespaceList != null) VisitedNamespaceList(namespaces); return base.VisitNamespaceList(namespaces); }
    public EventingVisitor(Action<NodeList> visitNodeList) { VisitedNodeList += visitNodeList; } public event Action<NodeList> VisitedNodeList; public override NodeList VisitNodeList(NodeList nodes) { if (VisitedNodeList != null) VisitedNodeList(nodes); return base.VisitNodeList(nodes); }
    public EventingVisitor(Action<OldExpression> visitOldExpression) { VisitedOldExpression += visitOldExpression; } public event Action<OldExpression> VisitedOldExpression; public override Expression VisitOldExpression(OldExpression oldExpression) { if (VisitedOldExpression != null) VisitedOldExpression(oldExpression); return base.VisitOldExpression(oldExpression); }
    public EventingVisitor(Action<Parameter> visitParameter) { VisitedParameter += visitParameter; } public event Action<Parameter> VisitedParameter; public override Expression VisitParameter(Parameter parameter) { if (VisitedParameter != null) VisitedParameter(parameter); return base.VisitParameter(parameter); }
    public EventingVisitor(Action<ParameterList> visitParameterList) { VisitedParameterList += visitParameterList; } public event Action<ParameterList> VisitedParameterList; public override ParameterList VisitParameterList(ParameterList parameterList) { if (VisitedParameterList != null) VisitedParameterList(parameterList); return base.VisitParameterList(parameterList); }
    public EventingVisitor(Action<PostfixExpression> visitPostfixExpression) { VisitedPostfixExpression += visitPostfixExpression; } public event Action<PostfixExpression> VisitedPostfixExpression; public override Expression VisitPostfixExpression(PostfixExpression pExpr) { if (VisitedPostfixExpression != null) VisitedPostfixExpression(pExpr); return base.VisitPostfixExpression(pExpr); }
    public EventingVisitor(Action<PrefixExpression> visitPrefixExpression) { VisitedPrefixExpression += visitPrefixExpression; } public event Action<PrefixExpression> VisitedPrefixExpression; public override Expression VisitPrefixExpression(PrefixExpression pExpr) { if (VisitedPrefixExpression != null) VisitedPrefixExpression(pExpr); return base.VisitPrefixExpression(pExpr); }
    public EventingVisitor(Action<Property> visitProperty) { VisitedProperty += visitProperty; } public event Action<Property> VisitedProperty; public override Property VisitProperty(Property property) { if (VisitedProperty != null) VisitedProperty(property); return base.VisitProperty(property); }
    public EventingVisitor(Action<QualifiedIdentifier> visitQualifiedIdentifier) { VisitedQualifiedIdentifier += visitQualifiedIdentifier; } public event Action<QualifiedIdentifier> VisitedQualifiedIdentifier; public override Expression VisitQualifiedIdentifier(QualifiedIdentifier qualifiedIdentifier) { if (VisitedQualifiedIdentifier != null) VisitedQualifiedIdentifier(qualifiedIdentifier); return base.VisitQualifiedIdentifier(qualifiedIdentifier); }
    public EventingVisitor(Action<Quantifier> visitQuantifier) { VisitedQuantifier += visitQuantifier; } public event Action<Quantifier> VisitedQuantifier; public override Expression VisitQuantifier(Quantifier quantifier) { if (VisitedQuantifier != null) VisitedQuantifier(quantifier); return base.VisitQuantifier(quantifier); }
    public EventingVisitor(Action<QueryAggregate> visitQueryAggregate) { VisitedQueryAggregate += visitQueryAggregate; } public event Action<QueryAggregate> VisitedQueryAggregate; public override Node VisitQueryAggregate(QueryAggregate qa) { if (VisitedQueryAggregate != null) VisitedQueryAggregate(qa); return base.VisitQueryAggregate(qa); }
    public EventingVisitor(Action<QueryAlias> visitQueryAlias) { VisitedQueryAlias += visitQueryAlias; } public event Action<QueryAlias> VisitedQueryAlias; public override Node VisitQueryAlias(QueryAlias alias) { if (VisitedQueryAlias != null) VisitedQueryAlias(alias); return base.VisitQueryAlias(alias); }
    public EventingVisitor(Action<QueryAxis> visitQueryAxis) { VisitedQueryAxis += visitQueryAxis; } public event Action<QueryAxis> VisitedQueryAxis; public override Node VisitQueryAxis(QueryAxis axis) { if (VisitedQueryAxis != null) VisitedQueryAxis(axis); return base.VisitQueryAxis(axis); }
    public EventingVisitor(Action<QueryCommit> visitQueryCommit) { VisitedQueryCommit += visitQueryCommit; } public event Action<QueryCommit> VisitedQueryCommit; public override Node VisitQueryCommit(QueryCommit qc) { if (VisitedQueryCommit != null) VisitedQueryCommit(qc); return base.VisitQueryCommit(qc); }
    public EventingVisitor(Action<QueryContext> visitQueryContext) { VisitedQueryContext += visitQueryContext; } public event Action<QueryContext> VisitedQueryContext; public override Node VisitQueryContext(QueryContext context) { if (VisitedQueryContext != null) VisitedQueryContext(context); return base.VisitQueryContext(context); }
    public EventingVisitor(Action<QueryDelete> visitQueryDelete) { VisitedQueryDelete += visitQueryDelete; } public event Action<QueryDelete> VisitedQueryDelete; public override Node VisitQueryDelete(QueryDelete delete) { if (VisitedQueryDelete != null) VisitedQueryDelete(delete); return base.VisitQueryDelete(delete); }
    public EventingVisitor(Action<QueryDifference> visitQueryDifference) { VisitedQueryDifference += visitQueryDifference; } public event Action<QueryDifference> VisitedQueryDifference; public override Node VisitQueryDifference(QueryDifference diff) { if (VisitedQueryDifference != null) VisitedQueryDifference(diff); return base.VisitQueryDifference(diff); }
    public EventingVisitor(Action<QueryDistinct> visitQueryDistinct) { VisitedQueryDistinct += visitQueryDistinct; } public event Action<QueryDistinct> VisitedQueryDistinct; public override Node VisitQueryDistinct(QueryDistinct distinct) { if (VisitedQueryDistinct != null) VisitedQueryDistinct(distinct); return base.VisitQueryDistinct(distinct); }
    public EventingVisitor(Action<QueryExists> visitQueryExists) { VisitedQueryExists += visitQueryExists; } public event Action<QueryExists> VisitedQueryExists; public override Node VisitQueryExists(QueryExists exists) { if (VisitedQueryExists != null) VisitedQueryExists(exists); return base.VisitQueryExists(exists); }
    public EventingVisitor(Action<QueryFilter> visitQueryFilter) { VisitedQueryFilter += visitQueryFilter; } public event Action<QueryFilter> VisitedQueryFilter; public override Node VisitQueryFilter(QueryFilter filter) { if (VisitedQueryFilter != null) VisitedQueryFilter(filter); return base.VisitQueryFilter(filter); }
    public EventingVisitor(Action<QueryGeneratedType> visitQueryGeneratedType) { VisitedQueryGeneratedType += visitQueryGeneratedType; } public event Action<QueryGeneratedType> VisitedQueryGeneratedType; public override Statement VisitQueryGeneratedType(QueryGeneratedType qgt) { if (VisitedQueryGeneratedType != null) VisitedQueryGeneratedType(qgt); return base.VisitQueryGeneratedType(qgt); }
    public EventingVisitor(Action<QueryGroupBy> visitQueryGroupBy) { VisitedQueryGroupBy += visitQueryGroupBy; } public event Action<QueryGroupBy> VisitedQueryGroupBy; public override Node VisitQueryGroupBy(QueryGroupBy groupby) { if (VisitedQueryGroupBy != null) VisitedQueryGroupBy(groupby); return base.VisitQueryGroupBy(groupby); }
    public EventingVisitor(Action<QueryInsert> visitQueryInsert) { VisitedQueryInsert += visitQueryInsert; } public event Action<QueryInsert> VisitedQueryInsert; public override Node VisitQueryInsert(QueryInsert insert) { if (VisitedQueryInsert != null) VisitedQueryInsert(insert); return base.VisitQueryInsert(insert); }
    public EventingVisitor(Action<QueryIntersection> visitQueryIntersection) { VisitedQueryIntersection += visitQueryIntersection; } public event Action<QueryIntersection> VisitedQueryIntersection; public override Node VisitQueryIntersection(QueryIntersection intersection) { if (VisitedQueryIntersection != null) VisitedQueryIntersection(intersection); return base.VisitQueryIntersection(intersection); }
    public EventingVisitor(Action<QueryIterator> visitQueryIterator) { VisitedQueryIterator += visitQueryIterator; } public event Action<QueryIterator> VisitedQueryIterator; public override Node VisitQueryIterator(QueryIterator xiterator) { if (VisitedQueryIterator != null) VisitedQueryIterator(xiterator); return base.VisitQueryIterator(xiterator); }
    public EventingVisitor(Action<QueryJoin> visitQueryJoin) { VisitedQueryJoin += visitQueryJoin; } public event Action<QueryJoin> VisitedQueryJoin; public override Node VisitQueryJoin(QueryJoin join) { if (VisitedQueryJoin != null) VisitedQueryJoin(join); return base.VisitQueryJoin(join); }
    public EventingVisitor(Action<QueryLimit> visitQueryLimit) { VisitedQueryLimit += visitQueryLimit; } public event Action<QueryLimit> VisitedQueryLimit; public override Node VisitQueryLimit(QueryLimit limit) { if (VisitedQueryLimit != null) VisitedQueryLimit(limit); return base.VisitQueryLimit(limit); }
    public EventingVisitor(Action<QueryOrderBy> visitQueryOrderBy) { VisitedQueryOrderBy += visitQueryOrderBy; } public event Action<QueryOrderBy> VisitedQueryOrderBy; public override Node VisitQueryOrderBy(QueryOrderBy orderby) { if (VisitedQueryOrderBy != null) VisitedQueryOrderBy(orderby); return base.VisitQueryOrderBy(orderby); }
    public EventingVisitor(Action<QueryOrderItem> visitQueryOrderItem) { VisitedQueryOrderItem += visitQueryOrderItem; } public event Action<QueryOrderItem> VisitedQueryOrderItem; public override Node VisitQueryOrderItem(QueryOrderItem item) { if (VisitedQueryOrderItem != null) VisitedQueryOrderItem(item); return base.VisitQueryOrderItem(item); }
    public EventingVisitor(Action<QueryPosition> visitQueryPosition) { VisitedQueryPosition += visitQueryPosition; } public event Action<QueryPosition> VisitedQueryPosition; public override Node VisitQueryPosition(QueryPosition position) { if (VisitedQueryPosition != null) VisitedQueryPosition(position); return base.VisitQueryPosition(position); }
    public EventingVisitor(Action<QueryProject> visitQueryProject) { VisitedQueryProject += visitQueryProject; } public event Action<QueryProject> VisitedQueryProject; public override Node VisitQueryProject(QueryProject project) { if (VisitedQueryProject != null) VisitedQueryProject(project); return base.VisitQueryProject(project); }
    public EventingVisitor(Action<QueryQuantifiedExpression> visitQueryQuantifiedExpression) { VisitedQueryQuantifiedExpression += visitQueryQuantifiedExpression; } public event Action<QueryQuantifiedExpression> VisitedQueryQuantifiedExpression; public override Node VisitQueryQuantifiedExpression(QueryQuantifiedExpression qqe) { if (VisitedQueryQuantifiedExpression != null) VisitedQueryQuantifiedExpression(qqe); return base.VisitQueryQuantifiedExpression(qqe); }
    public EventingVisitor(Action<QueryQuantifier> visitQueryQuantifier) { VisitedQueryQuantifier += visitQueryQuantifier; } public event Action<QueryQuantifier> VisitedQueryQuantifier; public override Node VisitQueryQuantifier(QueryQuantifier qq) { if (VisitedQueryQuantifier != null) VisitedQueryQuantifier(qq); return base.VisitQueryQuantifier(qq); }
    public EventingVisitor(Action<QueryRollback> visitQueryRollback) { VisitedQueryRollback += visitQueryRollback; } public event Action<QueryRollback> VisitedQueryRollback; public override Node VisitQueryRollback(QueryRollback qr) { if (VisitedQueryRollback != null) VisitedQueryRollback(qr); return base.VisitQueryRollback(qr); }
    public EventingVisitor(Action<QuerySelect> visitQuerySelect) { VisitedQuerySelect += visitQuerySelect; } public event Action<QuerySelect> VisitedQuerySelect; public override Node VisitQuerySelect(QuerySelect select) { if (VisitedQuerySelect != null) VisitedQuerySelect(select); return base.VisitQuerySelect(select); }
    public EventingVisitor(Action<QuerySingleton> visitQuerySingleton) { VisitedQuerySingleton += visitQuerySingleton; } public event Action<QuerySingleton> VisitedQuerySingleton; public override Node VisitQuerySingleton(QuerySingleton singleton) { if (VisitedQuerySingleton != null) VisitedQuerySingleton(singleton); return base.VisitQuerySingleton(singleton); }
    public EventingVisitor(Action<QueryTransact> visitQueryTransact) { VisitedQueryTransact += visitQueryTransact; } public event Action<QueryTransact> VisitedQueryTransact; public override Node VisitQueryTransact(QueryTransact qt) { if (VisitedQueryTransact != null) VisitedQueryTransact(qt); return base.VisitQueryTransact(qt); }
    public EventingVisitor(Action<QueryTypeFilter> visitQueryTypeFilter) { VisitedQueryTypeFilter += visitQueryTypeFilter; } public event Action<QueryTypeFilter> VisitedQueryTypeFilter; public override Node VisitQueryTypeFilter(QueryTypeFilter filter) { if (VisitedQueryTypeFilter != null) VisitedQueryTypeFilter(filter); return base.VisitQueryTypeFilter(filter); }
    public EventingVisitor(Action<QueryUnion> visitQueryUnion) { VisitedQueryUnion += visitQueryUnion; } public event Action<QueryUnion> VisitedQueryUnion; public override Node VisitQueryUnion(QueryUnion union) { if (VisitedQueryUnion != null) VisitedQueryUnion(union); return base.VisitQueryUnion(union); }
    public EventingVisitor(Action<QueryUpdate> visitQueryUpdate) { VisitedQueryUpdate += visitQueryUpdate; } public event Action<QueryUpdate> VisitedQueryUpdate; public override Node VisitQueryUpdate(QueryUpdate update) { if (VisitedQueryUpdate != null) VisitedQueryUpdate(update); return base.VisitQueryUpdate(update); }
    public EventingVisitor(Action<QueryYielder> visitQueryYielder) { VisitedQueryYielder += visitQueryYielder; } public event Action<QueryYielder> VisitedQueryYielder; public override Node VisitQueryYielder(QueryYielder yielder) { if (VisitedQueryYielder != null) VisitedQueryYielder(yielder); return base.VisitQueryYielder(yielder); }
    public EventingVisitor(Action<RefTypeExpression> visitRefTypeExpression) { VisitedRefTypeExpression += visitRefTypeExpression; } public event Action<RefTypeExpression> VisitedRefTypeExpression; public override Expression VisitRefTypeExpression(RefTypeExpression reftypexp) { if (VisitedRefTypeExpression != null) VisitedRefTypeExpression(reftypexp); return base.VisitRefTypeExpression(reftypexp); }
    public EventingVisitor(Action<RefValueExpression> visitRefValueExpression) { VisitedRefValueExpression += visitRefValueExpression; } public event Action<RefValueExpression> VisitedRefValueExpression; public override Expression VisitRefValueExpression(RefValueExpression refvalexp) { if (VisitedRefValueExpression != null) VisitedRefValueExpression(refvalexp); return base.VisitRefValueExpression(refvalexp); }
    public EventingVisitor(Action<Repeat> visitRepeat) { VisitedRepeat += visitRepeat; } public event Action<Repeat> VisitedRepeat; public override Statement VisitRepeat(Repeat repeat) { if (VisitedRepeat != null) VisitedRepeat(repeat); return base.VisitRepeat(repeat); }
    public EventingVisitor(Action<RequiresList> visitRequiresList) { VisitedRequiresList += visitRequiresList; } public event Action<RequiresList> VisitedRequiresList; public override RequiresList VisitRequiresList(RequiresList Requires) { if (VisitedRequiresList != null) VisitedRequiresList(Requires); return base.VisitRequiresList(Requires); }
    public EventingVisitor(Action<RequiresOtherwise> visitRequiresOtherwise) { VisitedRequiresOtherwise += visitRequiresOtherwise; } public event Action<RequiresOtherwise> VisitedRequiresOtherwise; public override RequiresOtherwise VisitRequiresOtherwise(RequiresOtherwise otherwise) { if (VisitedRequiresOtherwise != null) VisitedRequiresOtherwise(otherwise); return base.VisitRequiresOtherwise(otherwise); }
    public EventingVisitor(Action<RequiresPlain> visitRequiresPlain) { VisitedRequiresPlain += visitRequiresPlain; } public event Action<RequiresPlain> VisitedRequiresPlain; public override RequiresPlain VisitRequiresPlain(RequiresPlain plain) { if (VisitedRequiresPlain != null) VisitedRequiresPlain(plain); return base.VisitRequiresPlain(plain); }
    public EventingVisitor(Action<ResourceUse> visitResourceUse) { VisitedResourceUse += visitResourceUse; } public event Action<ResourceUse> VisitedResourceUse; public override Statement VisitResourceUse(ResourceUse resourceUse) { if (VisitedResourceUse != null) VisitedResourceUse(resourceUse); return base.VisitResourceUse(resourceUse); }
    public EventingVisitor(Action<Return> visitReturn) { VisitedReturn += visitReturn; } public event Action<Return> VisitedReturn; public override Statement VisitReturn(Return Return) { if (VisitedReturn != null) VisitedReturn(Return); return base.VisitReturn(Return); }
    public EventingVisitor(Action<SecurityAttribute> visitSecurityAttribute) { VisitedSecurityAttribute += visitSecurityAttribute; } public event Action<SecurityAttribute> VisitedSecurityAttribute; public override SecurityAttribute VisitSecurityAttribute(SecurityAttribute attribute) { if (VisitedSecurityAttribute != null) VisitedSecurityAttribute(attribute); return base.VisitSecurityAttribute(attribute); }
    public EventingVisitor(Action<SecurityAttributeList> visitSecurityAttributeList) { VisitedSecurityAttributeList += visitSecurityAttributeList; } public event Action<SecurityAttributeList> VisitedSecurityAttributeList; public override SecurityAttributeList VisitSecurityAttributeList(SecurityAttributeList attributes) { if (VisitedSecurityAttributeList != null) VisitedSecurityAttributeList(attributes); return base.VisitSecurityAttributeList(attributes); }
    public EventingVisitor(Action<SetterValue> visitSetterValue) { VisitedSetterValue += visitSetterValue; } public event Action<SetterValue> VisitedSetterValue; public override Expression VisitSetterValue(SetterValue value) { if (VisitedSetterValue != null) VisitedSetterValue(value); return base.VisitSetterValue(value); }
    public EventingVisitor(Action<StackAlloc> visitStackAlloc) { VisitedStackAlloc += visitStackAlloc; } public event Action<StackAlloc> VisitedStackAlloc; public override Expression VisitStackAlloc(StackAlloc alloc) { if (VisitedStackAlloc != null) VisitedStackAlloc(alloc); return base.VisitStackAlloc(alloc); }
    public EventingVisitor(Action<StatementList> visitStatementList) { VisitedStatementList += visitStatementList; } public event Action<StatementList> VisitedStatementList; public override StatementList VisitStatementList(StatementList statements) { if (VisitedStatementList != null) VisitedStatementList(statements); return base.VisitStatementList(statements); }
    public EventingVisitor(Action<StatementSnippet> visitStatementSnippet) { VisitedStatementSnippet += visitStatementSnippet; } public event Action<StatementSnippet> VisitedStatementSnippet; public override StatementSnippet VisitStatementSnippet(StatementSnippet snippet) { if (VisitedStatementSnippet != null) VisitedStatementSnippet(snippet); return base.VisitStatementSnippet(snippet); }
    public EventingVisitor(Action<StaticInitializer> visitStaticInitializer) { VisitedStaticInitializer += visitStaticInitializer; } public event Action<StaticInitializer> VisitedStaticInitializer; public override StaticInitializer VisitStaticInitializer(StaticInitializer cons) { if (VisitedStaticInitializer != null) VisitedStaticInitializer(cons); return base.VisitStaticInitializer(cons); }
    public EventingVisitor(Action<Struct> visitStruct) { VisitedStruct += visitStruct; } public event Action<Struct> VisitedStruct; public override Struct VisitStruct(Struct Struct) { if (VisitedStruct != null) VisitedStruct(Struct); return base.VisitStruct(Struct); }
    public EventingVisitor(Action<Switch> visitSwitch) { VisitedSwitch += visitSwitch; } public event Action<Switch> VisitedSwitch; public override Statement VisitSwitch(Switch Switch) { if (VisitedSwitch != null) VisitedSwitch(Switch); return base.VisitSwitch(Switch); }
    public EventingVisitor(Action<SwitchCase> visitSwitchCase) { VisitedSwitchCase += visitSwitchCase; } public event Action<SwitchCase> VisitedSwitchCase; public override SwitchCase VisitSwitchCase(SwitchCase switchCase) { if (VisitedSwitchCase != null) VisitedSwitchCase(switchCase); return base.VisitSwitchCase(switchCase); }
    public EventingVisitor(Action<SwitchCaseList> visitSwitchCaseList) { VisitedSwitchCaseList += visitSwitchCaseList; } public event Action<SwitchCaseList> VisitedSwitchCaseList; public override SwitchCaseList VisitSwitchCaseList(SwitchCaseList switchCases) { if (VisitedSwitchCaseList != null) VisitedSwitchCaseList(switchCases); return base.VisitSwitchCaseList(switchCases); }
    public EventingVisitor(Action<SwitchInstruction> visitSwitchInstruction) { VisitedSwitchInstruction += visitSwitchInstruction; } public event Action<SwitchInstruction> VisitedSwitchInstruction; public override Statement VisitSwitchInstruction(SwitchInstruction switchInstruction) { if (VisitedSwitchInstruction != null) VisitedSwitchInstruction(switchInstruction); return base.VisitSwitchInstruction(switchInstruction); }
    public event Action<Expression> VisitedTargetExpression; public override Expression VisitTargetExpression(Expression expression) { if (VisitedTargetExpression != null) VisitedTargetExpression(expression); return base.VisitTargetExpression(expression); }
    public EventingVisitor(Action<TemplateInstance> visitTemplateInstance) { VisitedTemplateInstance += visitTemplateInstance; } public event Action<TemplateInstance> VisitedTemplateInstance; public override Expression VisitTemplateInstance(TemplateInstance templateInstance) { if (VisitedTemplateInstance != null) VisitedTemplateInstance(templateInstance); return base.VisitTemplateInstance(templateInstance); }
    public EventingVisitor(Action<TernaryExpression> visitTernaryExpression) { VisitedTernaryExpression += visitTernaryExpression; } public event Action<TernaryExpression> VisitedTernaryExpression; public override Expression VisitTernaryExpression(TernaryExpression expression) { if (VisitedTernaryExpression != null) VisitedTernaryExpression(expression); return base.VisitTernaryExpression(expression); }
    public EventingVisitor(Action<This> visitThis) { VisitedThis += visitThis; } public event Action<This> VisitedThis; public override Expression VisitThis(This This) { if (VisitedThis != null) VisitedThis(This); return base.VisitThis(This); }
    public EventingVisitor(Action<Throw> visitThrow) { VisitedThrow += visitThrow; } public event Action<Throw> VisitedThrow; public override Statement VisitThrow(Throw Throw) { if (VisitedThrow != null) VisitedThrow(Throw); return base.VisitThrow(Throw); }
    public EventingVisitor(Action<Try> visitTry) { VisitedTry += visitTry; } public event Action<Try> VisitedTry; public override Statement VisitTry(Try Try) { if (VisitedTry != null) VisitedTry(Try); return base.VisitTry(Try); }
    public EventingVisitor(Action<TupleType> visitTupleType) { VisitedTupleType += visitTupleType; } public event Action<TupleType> VisitedTupleType; public override TupleType VisitTupleType(TupleType tuple) { if (VisitedTupleType != null) VisitedTupleType(tuple); return base.VisitTupleType(tuple); }
    public EventingVisitor(Action<TypeAlias> visitTypeAlias) { VisitedTypeAlias += visitTypeAlias; } public event Action<TypeAlias> VisitedTypeAlias; public override TypeAlias VisitTypeAlias(TypeAlias tAlias) { if (VisitedTypeAlias != null) VisitedTypeAlias(tAlias); return base.VisitTypeAlias(tAlias); }
    public EventingVisitor(Action<TypeContract> visitTypeContract) { VisitedTypeContract += visitTypeContract; } public event Action<TypeContract> VisitedTypeContract; public override TypeContract VisitTypeContract(TypeContract contract) { if (VisitedTypeContract != null) VisitedTypeContract(contract); return base.VisitTypeContract(contract); }
    public EventingVisitor(Action<TypeIntersection> visitTypeIntersection) { VisitedTypeIntersection += visitTypeIntersection; } public event Action<TypeIntersection> VisitedTypeIntersection; public override TypeIntersection VisitTypeIntersection(TypeIntersection typeIntersection) { if (VisitedTypeIntersection != null) VisitedTypeIntersection(typeIntersection); return base.VisitTypeIntersection(typeIntersection); }
    public EventingVisitor(Action<TypeMemberSnippet> visitTypeMemberSnippet) { VisitedTypeMemberSnippet += visitTypeMemberSnippet; } public event Action<TypeMemberSnippet> VisitedTypeMemberSnippet; public override TypeMemberSnippet VisitTypeMemberSnippet(TypeMemberSnippet snippet) { if (VisitedTypeMemberSnippet != null) VisitedTypeMemberSnippet(snippet); return base.VisitTypeMemberSnippet(snippet); }
    public EventingVisitor(Action<TypeModifier> visitTypeModifier) { VisitedTypeModifier += visitTypeModifier; } public event Action<TypeModifier> VisitedTypeModifier; public override TypeModifier VisitTypeModifier(TypeModifier typeModifier) { if (VisitedTypeModifier != null) VisitedTypeModifier(typeModifier); return base.VisitTypeModifier(typeModifier); }
    public EventingVisitor(Action<TypeNode> visitTypeNode) { VisitedTypeNode += visitTypeNode; } public event Action<TypeNode> VisitedTypeNode; public override TypeNode VisitTypeNode(TypeNode typeNode) { if (VisitedTypeNode != null) VisitedTypeNode(typeNode); return base.VisitTypeNode(typeNode); }
    public EventingVisitor(Action<TypeNodeList> visitTypeNodeList) { VisitedTypeNodeList += visitTypeNodeList; } public event Action<TypeNodeList> VisitedTypeNodeList; public override TypeNodeList VisitTypeNodeList(TypeNodeList types) { if (VisitedTypeNodeList != null) VisitedTypeNodeList(types); return base.VisitTypeNodeList(types); }
    public event Action<TypeNode> VisitedTypeParameter; public override TypeNode VisitTypeParameter(TypeNode typeParameter) { if (VisitedTypeParameter != null) VisitedTypeParameter(typeParameter); return base.VisitTypeParameter(typeParameter); }
    public event Action<TypeNodeList> VisitedTypeParameterList; public override TypeNodeList VisitTypeParameterList(TypeNodeList typeParameters) { if (VisitedTypeParameterList != null) VisitedTypeParameterList(typeParameters); return base.VisitTypeParameterList(typeParameters); }
    public event Action<TypeNode> VisitedTypeNodeReference; public override TypeNode VisitTypeReference(TypeNode type) { if (VisitedTypeNodeReference != null) VisitedTypeNodeReference(type); return base.VisitTypeReference(type); }
    public EventingVisitor(Action<TypeReference> visitTypeReference) { VisitedTypeReference += visitTypeReference; } public event Action<TypeReference> VisitedTypeReference; public override TypeReference VisitTypeReference(TypeReference type) { if (VisitedTypeReference != null) VisitedTypeReference(type); return base.VisitTypeReference(type); }
    public event Action<TypeNodeList> VisitedTypeReferenceList; public override TypeNodeList VisitTypeReferenceList(TypeNodeList typeReferences) { if (VisitedTypeReferenceList != null) VisitedTypeReferenceList(typeReferences); return base.VisitTypeReferenceList(typeReferences); }
    public EventingVisitor(Action<Typeswitch> visitTypeswitch) { VisitedTypeswitch += visitTypeswitch; } public event Action<Typeswitch> VisitedTypeswitch; public override Statement VisitTypeswitch(Typeswitch Typeswitch) { if (VisitedTypeswitch != null) VisitedTypeswitch(Typeswitch); return base.VisitTypeswitch(Typeswitch); }
    public EventingVisitor(Action<TypeswitchCase> visitTypeswitchCase) { VisitedTypeswitchCase += visitTypeswitchCase; } public event Action<TypeswitchCase> VisitedTypeswitchCase; public override TypeswitchCase VisitTypeswitchCase(TypeswitchCase typeswitchCase) { if (VisitedTypeswitchCase != null) VisitedTypeswitchCase(typeswitchCase); return base.VisitTypeswitchCase(typeswitchCase); }
    public EventingVisitor(Action<TypeswitchCaseList> visitTypeswitchCaseList) { VisitedTypeswitchCaseList += visitTypeswitchCaseList; } public event Action<TypeswitchCaseList> VisitedTypeswitchCaseList; public override TypeswitchCaseList VisitTypeswitchCaseList(TypeswitchCaseList typeswitchCases) { if (VisitedTypeswitchCaseList != null) VisitedTypeswitchCaseList(typeswitchCases); return base.VisitTypeswitchCaseList(typeswitchCases); }
    public EventingVisitor(Action<TypeUnion> visitTypeUnion) { VisitedTypeUnion += visitTypeUnion; } public event Action<TypeUnion> VisitedTypeUnion; public override TypeUnion VisitTypeUnion(TypeUnion typeUnion) { if (VisitedTypeUnion != null) VisitedTypeUnion(typeUnion); return base.VisitTypeUnion(typeUnion); }
    public EventingVisitor(Action<UnaryExpression> visitUnaryExpression) { VisitedUnaryExpression += visitUnaryExpression; } public event Action<UnaryExpression> VisitedUnaryExpression; public override Expression VisitUnaryExpression(UnaryExpression unaryExpression) { if (VisitedUnaryExpression != null) VisitedUnaryExpression(unaryExpression); return base.VisitUnaryExpression(unaryExpression); }
    public event Action<Node> VisitedUnknownNodeType; public override Node VisitUnknownNodeType(Node node) { if (VisitedUnknownNodeType != null) VisitedUnknownNodeType(node); return base.VisitUnknownNodeType(node); }
    public EventingVisitor(Action<UsedNamespace> visitUsedNamespace) { VisitedUsedNamespace += visitUsedNamespace; } public event Action<UsedNamespace> VisitedUsedNamespace; public override UsedNamespace VisitUsedNamespace(UsedNamespace usedNamespace) { if (VisitedUsedNamespace != null) VisitedUsedNamespace(usedNamespace); return base.VisitUsedNamespace(usedNamespace); }
    public EventingVisitor(Action<UsedNamespaceList> visitUsedNamespaceList) { VisitedUsedNamespaceList += visitUsedNamespaceList; } public event Action<UsedNamespaceList> VisitedUsedNamespaceList; public override UsedNamespaceList VisitUsedNamespaceList(UsedNamespaceList usedNspaces) { if (VisitedUsedNamespaceList != null) VisitedUsedNamespaceList(usedNspaces); return base.VisitUsedNamespaceList(usedNspaces); }
    public EventingVisitor(Action<VariableDeclaration> visitVariableDeclaration) { VisitedVariableDeclaration += visitVariableDeclaration; } public event Action<VariableDeclaration> VisitedVariableDeclaration; public override Statement VisitVariableDeclaration(VariableDeclaration variableDeclaration) { if (VisitedVariableDeclaration != null) VisitedVariableDeclaration(variableDeclaration); return base.VisitVariableDeclaration(variableDeclaration); }
    public EventingVisitor(Action<While> visitWhile) { VisitedWhile += visitWhile; } public event Action<While> VisitedWhile; public override Statement VisitWhile(While While) { if (VisitedWhile != null) VisitedWhile(While); return base.VisitWhile(While); }
    public EventingVisitor(Action<Yield> visitYield) { VisitedYield += visitYield; } public event Action<Yield> VisitedYield; public override Statement VisitYield(Yield Yield) { if (VisitedYield != null) VisitedYield(Yield); return base.VisitYield(Yield); }
  }
}
